package com.dimanche.library_base.utils;

import android.os.Environment;

import org.mozilla.universalchardet.UniversalDetector;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

/**
 * author : Dimanche
 * date   : 2020/7/29 16:36
 * desc   : 文件读写模块
 * version: 1.0
 */
public class FileUtils {
    private static final String TAG = "FileUtils";

    /**
     * 获取存储根目录
     *
     * @return
     */
    public static String getRootDir() {
        String sdr = "";
        //判断外部存储是否可用
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            sdr = Environment.getExternalStorageDirectory().getAbsolutePath();
        }
        return sdr;
    }

    /**
     * 判断目录是否存在，不存在则判断是否创建成功
     *
     * @param file 文件
     * @return {@code true}: 存在或创建成功<br>{@code false}: 不存在或创建失败
     */
    public static boolean createOrExistsDir(final File file) {
        // 如果存在，是目录则返回 true，是文件则返回 false，不存在则返回是否创建成功
        return file != null && (file.exists() ? file.isDirectory() : file.mkdirs());
    }

    /**
     * 判断目录是否存在，不存在则判断是否创建成功
     *
     * @param dirPath 目录路径
     * @return {@code true}: 存在或创建成功<br>{@code false}: 不存在或创建失败
     */
    public static boolean createOrExistsDir(final String dirPath) {
        return createOrExistsDir(getFileByPath(dirPath));
    }

    /**
     * 根据文件路径获取文件
     *
     * @param filePath 文件路径
     * @return 文件
     */
    public static File getFileByPath(final String filePath) {
        return isSpace(filePath) ? null : new File(filePath);
    }

    private static boolean isSpace(final String s) {
        if (s == null) return true;
        for (int i = 0, len = s.length(); i < len; ++i) {
            if (!Character.isWhitespace(s.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断文件是否存在
     *
     * @param file 文件
     * @return {@code true}: 存在<br>{@code false}: 不存在
     */
    public static boolean isFileExists(final File file) {
        return file != null && file.exists();
    }

    /**
     * 判断文件是否存在，不存在则判断是否创建成功
     *
     * @param file 文件
     * @return {@code true}: 存在或创建成功<br>{@code false}: 不存在或创建失败
     */
    public static boolean createOrExistsFile(final File file) {
        if (file == null) {
            return false;
        }
        // 如果存在，是文件则返回 true，是目录则返回 false
        if (file.exists()) {
            return file.isFile();
        }
        if (!createOrExistsDir(file.getParentFile())) {
            return false;
        }
        try {
            return file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 创建文件夹
     *
     * @param pathStr
     */
    public static void creatFolder(String pathStr) {
        File file = new File(pathStr);
        if (!file.exists()) {
            file.mkdirs();
        }
    }

    /**
     * 将字符串写入到文件中
     *
     * @param filePath 文件路径包括文件名
     * @param msg      要写入的内容
     */
    public static void writeString(String filePath, String msg) throws Exception {
        File file = new File(filePath);
        if (file.isDirectory()) {
            new Exception("文件路径为文件夹");
            return;
        }
        if (!file.exists()) {
            file.createNewFile();
        }
        FileWriter fileWriter = new FileWriter(file, true);
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.write(msg);
        bufferedWriter.newLine();
        bufferedWriter.flush();
        fileWriter.flush();
        bufferedWriter.close();
        fileWriter.close();
    }

    /**
     * 获取指定文件的大小
     *
     * @param filePath 文件路径
     * @return 文件大小，单位KB
     */
    public static long getFileSize(String filePath) throws Exception {
        File file = new File(filePath);
        if (!file.exists()) {
            return 0;
        }
        if (file.isDirectory()) {
            throw new Exception("该路径为文件夹");
        }
         LogUtils.logi(TAG, "日志：" + file.length());
        return file.length() / 1024;
    }

    /**
     * 获取指定文件夹下一级文件的数量
     *
     * @param folderPath 文件夹路径
     * @return 文件数量
     */
    public static int getFolderSize(String folderPath) {
        int fileCount = 0;
        File file = new File(folderPath);
        if (file.exists() && file.isDirectory()) {
            return file.listFiles().length;
        }
        return fileCount;
    }

    /**
     * 获取指定文件夹下的一级文件数量，并且按照文件名字升序排列
     *
     * @param folderPath 文件夹路径
     * @return
     */
    public static List<String> getFileListOrderName(String folderPath) {
        List<String> fileList = new ArrayList<>();
        File file = new File(folderPath);
        if (file.exists() && file.isDirectory()) {
            fileList = SortUtils.sortFolderArr(file.list());
        }
        return fileList;

    }

    /**
     * 删除文件夹及文件夹下的所有文件
     *
     * @param folderPath 文件夹路径
     */
    public static void deleteFileDir(String folderPath) {
        File folderFile = new File(folderPath);
        if (!folderFile.isDirectory()) {
            return;
        }
        File[] files = folderFile.listFiles();
        for (File file : files) {
            if (!file.isDirectory()) {
                file.delete();
//                deleteFileDir(file.getAbsolutePath());
            }
        }
        if (folderFile.listFiles().length <= 0) {
            folderFile.delete();
        }
    }

    /**
     * 功能：Java读取txt文件的内容
     * 步骤：1：先获得文件句柄
     * 2：获得文件句柄当做是输入一个字节码流，需要对这个输入流进行读取
     * 3：读取到输入流后，需要读取生成字节流
     * 4：一行一行的输出。readline()。
     * 备注：需要考虑的是异常情况
     */
    public static String readTxtFile(File file) {
        StringBuffer stringBuffer = new StringBuffer();
        try {
            String encoding = getFileCharacterEnding(file);
            if (file.isFile() && file.exists()) { //判断文件是否存在
                InputStreamReader read = new InputStreamReader(
                        new FileInputStream(file), encoding);//考虑到编码格式
                BufferedReader bufferedReader = new BufferedReader(read);
                String lineTxt = null;
                while ((lineTxt = bufferedReader.readLine()) != null) {
                    stringBuffer.append(lineTxt);
                    System.out.println(lineTxt);
                }
                read.close();
            } else {
                System.out.println("找不到指定的文件");
            }
        } catch (Exception e) {
            System.out.println("读取文件内容出错");
            e.printStackTrace();
        }
        return stringBuffer.toString();
    }

    /**
     * 获取文件编码
     * @param filePath
     * @return
     * @throws Exception
     */
    public static String getFileCharacterEnding(File filePath) throws Exception {
        InputStream inputStream=new FileInputStream(filePath);
        String encoding = UniversalDetector.detectCharset(inputStream);
         LogUtils.logi(TAG,encoding);
        return encoding;
    }
    public static String getFileCharacterEnding(String filePath) throws Exception {
        InputStream inputStream=new FileInputStream(filePath);
        String encoding = UniversalDetector.detectCharset(inputStream);
         LogUtils.logi(TAG,encoding);
        return encoding;
    }


}
